/**
 * 根据输入的W值计算对应的RZ值
 * @param {number} w - 输入的W值
 * @param {Array} dataPoints - 
 * @returns {object} 包含计算结果、状态和说明的对象
 */
export function calculateRZFromW(w, dataPoints) {
    // 验证输入是否为有效数字
    if (isNaN(w) || !isFinite(w)) {
        return {
            success: false,
            message: "请输入有效的数字",
            rz: null,
            method: null
        };
    }
    w = Number(w);

    // 获取W的范围
    const minW = dataPoints[0].w;
    const maxW = dataPoints[dataPoints.length - 1].w;

    let x0, y0, x1, y1, method;

    // 确定使用的参考点和计算方法
    if (w < minW) {
        // 小于最小值，使用前两个点外推
        x0 = dataPoints[0].w;
        y0 = dataPoints[0].rz;
        x1 = dataPoints[1].w;
        y1 = dataPoints[1].rz;
        method = "外推（使用前两个数据点）";
    } else if (w > maxW) {
        // 大于最大值，使用最后两个点外推
        x0 = dataPoints[dataPoints.length - 2].w;
        y0 = dataPoints[dataPoints.length - 2].rz;
        x1 = dataPoints[dataPoints.length - 1].w;
        y1 = dataPoints[dataPoints.length - 1].rz;
        method = "外推（使用最后两个数据点）";
    } else if (w === maxW) {
        // 等于最大值，直接返回
        return {
            success: true,
            message: "精确匹配最大值",
            rz: parseFloat(dataPoints[dataPoints.length - 1].rz.toFixed(3)),
            method: "精确匹配"
        };
    } else if (w === minW) {
        // 等于最小值，直接返回
        return {
            success: true,
            message: "精确匹配最小值",
            rz: parseFloat(dataPoints[0].rz.toFixed(3)),
            method: "精确匹配"
        };
    } else {
        // 在范围内，找到对应的区间
        method = "插值（使用范围内两点）";
        for (let i = 0; i < dataPoints.length - 1; i++) {
            if (w >= dataPoints[i].w && w <= dataPoints[i + 1].w) {
                x0 = dataPoints[i].w;
                y0 = dataPoints[i].rz;
                x1 = dataPoints[i + 1].w;
                y1 = dataPoints[i + 1].rz;
                break;
            }
        }
    }

    // 检查是否找到精确匹配的值（考虑浮点数精度）
    const exactMatch = dataPoints.find(point => Math.abs(point.w - w) < 0.0001);
    if (exactMatch) {
        return {
            success: true,
            message: "精确匹配数据点",
            rz: parseFloat(exactMatch.rz.toFixed(3)),
            method: "精确匹配"
        };
    }

    // 线性计算（插值或外推）
    const slope = (y1 - y0) / (x1 - x0); // 计算斜率
    const rz = y0 + (w - x0) * slope;

    // 返回结果对象
    return {
        success: true,
        message: `计算完成（${method}）`,
        rz: parseFloat(rz.toFixed(2)),
        method: method
    };
}

/**
 * 根据输入的RZ值计算对应的W值
 * @param {number} rz - 输入的RZ值
 * @returns {object} 包含计算结果、状态和说明的对象
 */
export function calculateWFromRZ(rz, dataPoints) {
    // 验证输入是否为有效数字
    if (isNaN(rz) || !isFinite(rz)) {
        return {
            success: false,
            message: "请输入有效的数字",
            w: null,
            method: null
        };
    }
    rz = Number(rz);
    // 获取数据范围
    const minRZ = dataPoints[0].rz;
    const maxRZ = dataPoints[dataPoints.length - 1].rz;

    let x0, y0, x1, y1, method;

    // 确定使用的参考点和计算方法
    if (rz < minRZ) {
        // 小于最小值，使用前两个点外推
        x0 = dataPoints[0].rz;
        y0 = dataPoints[0].w;
        x1 = dataPoints[1].rz;
        y1 = dataPoints[1].w;
        method = "外推（使用前两个数据点）";
    } else if (rz > maxRZ) {
        // 大于最大值，使用最后两个点外推
        x0 = dataPoints[dataPoints.length - 2].rz;
        y0 = dataPoints[dataPoints.length - 2].w;
        x1 = dataPoints[dataPoints.length - 1].rz;
        y1 = dataPoints[dataPoints.length - 1].w;
        method = "外推（使用最后两个数据点）";
    } else if (rz === maxRZ) {
        // 等于最大值，直接返回
        return {
            success: true,
            message: "精确匹配最大值",
            w: parseFloat(dataPoints[dataPoints.length - 1].w.toFixed(3)),
            method: "精确匹配"
        };
    } else if (rz === minRZ) {
        // 等于最小值，直接返回
        return {
            success: true,
            message: "精确匹配最小值",
            w: parseFloat(dataPoints[0].w.toFixed(3)),
            method: "精确匹配"
        };
    } else {
        // 在范围内，找到对应的区间
        method = "插值（使用范围内两点）";
        for (let i = 0; i < dataPoints.length - 1; i++) {
            if (rz >= dataPoints[i].rz && rz <= dataPoints[i + 1].rz) {
                x0 = dataPoints[i].rz;
                y0 = dataPoints[i].w;
                x1 = dataPoints[i + 1].rz;
                y1 = dataPoints[i + 1].w;
                break;
            }
        }
    }

    // 检查是否找到精确匹配的值
    const exactMatch = dataPoints.find(point => Math.abs(point.rz - rz) < 0.0001);
    if (exactMatch) {
        return {
            success: true,
            message: "精确匹配数据点",
            w: parseFloat(exactMatch.w.toFixed(3)),
            method: "精确匹配"
        };
    }

    // 线性计算（插值或外推）
    const slope = (y1 - y0) / (x1 - x0); // 计算斜率
    const w = y0 + (rz - x0) * slope;

    // 返回结果对象
    return {
        success: true,
        message: `计算完成（${method}）`,
        w: parseFloat(w.toFixed(3)),
        method: method
    };
}

/**
 * 根据输入的水位Z值计算对应的流量Q值
 * @param {number} z - 输入的水位Z值
 * @returns {object} 包含计算结果、状态和说明的对象
 */
export function calculateQFromZ(z, dataPoints) {
    // 验证输入是否为有效数字
    if (isNaN(z) || !isFinite(z)) {
        return {
            success: false,
            message: "请输入有效的数字",
            q: null,
            method: null
        };
    }
    z = Number(z);
    // 获取水位Z的范围
    const minZ = dataPoints[0].z;
    const maxZ = dataPoints[dataPoints.length - 1].z;

    let x0, y0, x1, y1, method;

    // 确定使用的参考点和计算方法
    if (z < minZ) {
        // 小于最小值，使用前两个点外推
        x0 = dataPoints[0].z;
        y0 = dataPoints[0].q;
        x1 = dataPoints[1].z;
        y1 = dataPoints[1].q;
        method = "外推（使用前两个数据点）";
    } else if (z > maxZ) {
        // 大于最大值，使用最后两个点外推
        x0 = dataPoints[dataPoints.length - 2].z;
        y0 = dataPoints[dataPoints.length - 2].q;
        x1 = dataPoints[dataPoints.length - 1].z;
        y1 = dataPoints[dataPoints.length - 1].q;
        method = "外推（使用最后两个数据点）";
    } else if (z === maxZ) {
        // 等于最大值，直接返回
        return {
            success: true,
            message: "精确匹配最大水位值",
            q: parseFloat(dataPoints[dataPoints.length - 1].q.toFixed(3)),
            method: "精确匹配"
        };
    } else if (z === minZ) {
        // 等于最小值，直接返回
        return {
            success: true,
            message: "精确匹配最小水位值",
            q: parseFloat(dataPoints[0].q.toFixed(3)),
            method: "精确匹配"
        };
    } else {
        // 在范围内，找到对应的区间
        method = "插值（使用范围内两点）";
        for (let i = 0; i < dataPoints.length - 1; i++) {
            if (z >= dataPoints[i].z && z <= dataPoints[i + 1].z) {
                x0 = dataPoints[i].z;
                y0 = dataPoints[i].q;
                x1 = dataPoints[i + 1].z;
                y1 = dataPoints[i + 1].q;
                break;
            }
        }
    }

    // 检查是否找到精确匹配的值（考虑浮点数精度）
    const exactMatch = dataPoints.find(point => Math.abs(point.z - z) < 0.0001);
    if (exactMatch) {
        return {
            success: true,
            message: "精确匹配数据点",
            q: parseFloat(exactMatch.q.toFixed(3)),
            method: "精确匹配"
        };
    }

    // 线性计算（插值或外推）
    const slope = (y1 - y0) / (x1 - x0); // 计算斜率
    const q = y0 + (z - x0) * slope;

    // 返回结果对象
    return {
        success: true,
        message: `计算完成（${method}）`,
        q: parseFloat(q.toFixed(3)),
        method: method
    };
}
/**
 * 根据输入的流量Q值计算对应的水位Z值
 * @param {number} q - 输入的流量Q值
 * @returns {object} 包含计算结果、状态和说明的对象
 */
export function calculateZFromQ(q, dataPoints) {
    // 验证输入是否为有效数字
    if (isNaN(q) || !isFinite(q)) {
        return {
            success: false,
            message: "请输入有效的数字",
            z: null,
            method: null
        };
    }
    q = Number(q);
    // 获取流量Q的范围
    const minQ = dataPoints[0].q;
    const maxQ = dataPoints[dataPoints.length - 1].q;

    let x0, y0, x1, y1, method;

    // 确定使用的参考点和计算方法
    if (q < minQ) {
        // 小于最小值，使用前两个点外推
        x0 = dataPoints[0].q;
        y0 = dataPoints[0].z;
        x1 = dataPoints[1].q;
        y1 = dataPoints[1].z;
        method = "外推（使用前两个数据点）";
    } else if (q > maxQ) {
        // 大于最大值，使用最后两个点外推
        x0 = dataPoints[dataPoints.length - 2].q;
        y0 = dataPoints[dataPoints.length - 2].z;
        x1 = dataPoints[dataPoints.length - 1].q;
        y1 = dataPoints[dataPoints.length - 1].z;
        method = "外推（使用最后两个数据点）";
    } else if (q === maxQ) {
        // 等于最大值，直接返回
        return {
            success: true,
            message: "精确匹配最大流量值",
            z: parseFloat(dataPoints[dataPoints.length - 1].z.toFixed(3)),
            method: "精确匹配"
        };
    } else if (q === minQ) {
        // 等于最小值，直接返回
        return {
            success: true,
            message: "精确匹配最小流量值",
            z: parseFloat(dataPoints[0].z.toFixed(3)),
            method: "精确匹配"
        };
    } else {
        // 在范围内，找到对应的区间
        method = "插值（使用范围内两点）";
        for (let i = 0; i < dataPoints.length - 1; i++) {
            if (q >= dataPoints[i].q && q <= dataPoints[i + 1].q) {
                x0 = dataPoints[i].q;
                y0 = dataPoints[i].z;
                x1 = dataPoints[i + 1].q;
                y1 = dataPoints[i + 1].z;
                break;
            }
        }
    }

    // 检查是否找到精确匹配的值（考虑浮点数精度）
    const exactMatch = dataPoints.find(point => Math.abs(point.q - q) < 0.0001);
    if (exactMatch) {
        return {
            success: true,
            message: "精确匹配数据点",
            z: parseFloat(exactMatch.z.toFixed(3)),
            method: "精确匹配"
        };
    }

    // 线性计算（插值或外推）
    const slope = (y1 - y0) / (x1 - x0); // 计算斜率
    const z = y0 + (q - x0) * slope;

    // 返回结果对象
    return {
        success: true,
        message: `计算完成（${method}）`,
        z: parseFloat(z.toFixed(3)),
        method: method
    };
}
